﻿using System;
using System.ComponentModel;
using System.IO;
using System.Runtime.Serialization;

namespace HalconDotNet
{
	/// <summary>Represents an instance of a shape model for matching.</summary>
	// Token: 0x02000061 RID: 97
	[Serializable]
	public class HShapeModel : HHandle, ISerializable, ICloneable
	{
		// Token: 0x06001792 RID: 6034 RVA: 0x0000883B File Offset: 0x00006A3B
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HShapeModel() : base(HHandleBase.UNDEF)
		{
		}

		// Token: 0x06001793 RID: 6035 RVA: 0x00096F14 File Offset: 0x00095114
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HShapeModel(IntPtr handle) : base(handle)
		{
			this.AssertSemType();
		}

		// Token: 0x06001794 RID: 6036 RVA: 0x00096F23 File Offset: 0x00095123
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HShapeModel(HHandle handle) : base(handle)
		{
			this.AssertSemType();
		}

		// Token: 0x06001795 RID: 6037 RVA: 0x00096F32 File Offset: 0x00095132
		private void AssertSemType()
		{
			base.AssertSemType("shape_model");
		}

		// Token: 0x06001796 RID: 6038 RVA: 0x00096F3F File Offset: 0x0009513F
		internal static int LoadNew(IntPtr proc, int parIndex, int err, out HShapeModel obj)
		{
			obj = new HShapeModel(HHandleBase.UNDEF);
			return obj.Load(proc, parIndex, err);
		}

		// Token: 0x06001797 RID: 6039 RVA: 0x00096F58 File Offset: 0x00095158
		internal static int LoadNew(IntPtr proc, int parIndex, int err, out HShapeModel[] obj)
		{
			HTuple htuple;
			err = HTuple.LoadNew(proc, parIndex, err, out htuple);
			obj = new HShapeModel[htuple.Length];
			for (int i = 0; i < htuple.Length; i++)
			{
				obj[i] = new HShapeModel(HalconAPI.IsLegacyHandleMode() ? htuple[i].IP : htuple[i].H);
			}
			htuple.Dispose();
			return err;
		}

		/// <summary>
		///   Read a shape model from a file.
		///   Modified instance represents: Handle of the model.
		/// </summary>
		/// <param name="fileName">File name.</param>
		// Token: 0x06001798 RID: 6040 RVA: 0x00096FC8 File Offset: 0x000951C8
		public HShapeModel(string fileName)
		{
			IntPtr proc = HalconAPI.PreCall(917);
			HalconAPI.StoreS(proc, 0, fileName);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Prepare an anisotropically scaled shape model for matching from XLD contours.
		///   Modified instance represents: Handle of the model.
		/// </summary>
		/// <param name="contours">Input contours that will be used to create the model.</param>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">Smallest rotation of the pattern. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleRMin">Minimum scale of the pattern in the row direction. Default: 0.9</param>
		/// <param name="scaleRMax">Maximum scale of the pattern in the row direction. Default: 1.1</param>
		/// <param name="scaleRStep">Scale step length (resolution) in the row direction. Default: "auto"</param>
		/// <param name="scaleCMin">Minimum scale of the pattern in the column direction. Default: 0.9</param>
		/// <param name="scaleCMax">Maximum scale of the pattern in the column direction. Default: 1.1</param>
		/// <param name="scaleCStep">Scale step length (resolution) in the column direction. Default: "auto"</param>
		/// <param name="optimization">Kind of optimization and optionally method used for generating the model. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "ignore_local_polarity"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: 5</param>
		// Token: 0x06001799 RID: 6041 RVA: 0x00097014 File Offset: 0x00095214
		public HShapeModel(HXLDCont contours, HTuple numLevels, double angleStart, double angleExtent, HTuple angleStep, double scaleRMin, double scaleRMax, HTuple scaleRStep, double scaleCMin, double scaleCMax, HTuple scaleCStep, HTuple optimization, string metric, int minContrast)
		{
			IntPtr proc = HalconAPI.PreCall(935);
			HalconAPI.Store(proc, 1, contours);
			HalconAPI.Store(proc, 0, numLevels);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.Store(proc, 3, angleStep);
			HalconAPI.StoreD(proc, 4, scaleRMin);
			HalconAPI.StoreD(proc, 5, scaleRMax);
			HalconAPI.Store(proc, 6, scaleRStep);
			HalconAPI.StoreD(proc, 7, scaleCMin);
			HalconAPI.StoreD(proc, 8, scaleCMax);
			HalconAPI.Store(proc, 9, scaleCStep);
			HalconAPI.Store(proc, 10, optimization);
			HalconAPI.StoreS(proc, 11, metric);
			HalconAPI.StoreI(proc, 12, minContrast);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(numLevels);
			HalconAPI.UnpinTuple(angleStep);
			HalconAPI.UnpinTuple(scaleRStep);
			HalconAPI.UnpinTuple(scaleCStep);
			HalconAPI.UnpinTuple(optimization);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(contours);
		}

		/// <summary>
		///   Prepare an anisotropically scaled shape model for matching from XLD contours.
		///   Modified instance represents: Handle of the model.
		/// </summary>
		/// <param name="contours">Input contours that will be used to create the model.</param>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">Smallest rotation of the pattern. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleRMin">Minimum scale of the pattern in the row direction. Default: 0.9</param>
		/// <param name="scaleRMax">Maximum scale of the pattern in the row direction. Default: 1.1</param>
		/// <param name="scaleRStep">Scale step length (resolution) in the row direction. Default: "auto"</param>
		/// <param name="scaleCMin">Minimum scale of the pattern in the column direction. Default: 0.9</param>
		/// <param name="scaleCMax">Maximum scale of the pattern in the column direction. Default: 1.1</param>
		/// <param name="scaleCStep">Scale step length (resolution) in the column direction. Default: "auto"</param>
		/// <param name="optimization">Kind of optimization and optionally method used for generating the model. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "ignore_local_polarity"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: 5</param>
		// Token: 0x0600179A RID: 6042 RVA: 0x00097100 File Offset: 0x00095300
		public HShapeModel(HXLDCont contours, int numLevels, double angleStart, double angleExtent, double angleStep, double scaleRMin, double scaleRMax, double scaleRStep, double scaleCMin, double scaleCMax, double scaleCStep, string optimization, string metric, int minContrast)
		{
			IntPtr proc = HalconAPI.PreCall(935);
			HalconAPI.Store(proc, 1, contours);
			HalconAPI.StoreI(proc, 0, numLevels);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, angleStep);
			HalconAPI.StoreD(proc, 4, scaleRMin);
			HalconAPI.StoreD(proc, 5, scaleRMax);
			HalconAPI.StoreD(proc, 6, scaleRStep);
			HalconAPI.StoreD(proc, 7, scaleCMin);
			HalconAPI.StoreD(proc, 8, scaleCMax);
			HalconAPI.StoreD(proc, 9, scaleCStep);
			HalconAPI.StoreS(proc, 10, optimization);
			HalconAPI.StoreS(proc, 11, metric);
			HalconAPI.StoreI(proc, 12, minContrast);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(contours);
		}

		/// <summary>
		///   Prepare an isotropically scaled shape model for matching from XLD contours.
		///   Modified instance represents: Handle of the model.
		/// </summary>
		/// <param name="contours">Input contours that will be used to create the model.</param>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">Smallest rotation of the pattern. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleMin">Minimum scale of the pattern. Default: 0.9</param>
		/// <param name="scaleMax">Maximum scale of the pattern. Default: 1.1</param>
		/// <param name="scaleStep">Scale step length (resolution). Default: "auto"</param>
		/// <param name="optimization">Kind of optimization and optionally method used for generating the model. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "ignore_local_polarity"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: 5</param>
		// Token: 0x0600179B RID: 6043 RVA: 0x000971CC File Offset: 0x000953CC
		public HShapeModel(HXLDCont contours, HTuple numLevels, double angleStart, double angleExtent, HTuple angleStep, double scaleMin, double scaleMax, HTuple scaleStep, HTuple optimization, string metric, int minContrast)
		{
			IntPtr proc = HalconAPI.PreCall(936);
			HalconAPI.Store(proc, 1, contours);
			HalconAPI.Store(proc, 0, numLevels);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.Store(proc, 3, angleStep);
			HalconAPI.StoreD(proc, 4, scaleMin);
			HalconAPI.StoreD(proc, 5, scaleMax);
			HalconAPI.Store(proc, 6, scaleStep);
			HalconAPI.Store(proc, 7, optimization);
			HalconAPI.StoreS(proc, 8, metric);
			HalconAPI.StoreI(proc, 9, minContrast);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(numLevels);
			HalconAPI.UnpinTuple(angleStep);
			HalconAPI.UnpinTuple(scaleStep);
			HalconAPI.UnpinTuple(optimization);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(contours);
		}

		/// <summary>
		///   Prepare an isotropically scaled shape model for matching from XLD contours.
		///   Modified instance represents: Handle of the model.
		/// </summary>
		/// <param name="contours">Input contours that will be used to create the model.</param>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">Smallest rotation of the pattern. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleMin">Minimum scale of the pattern. Default: 0.9</param>
		/// <param name="scaleMax">Maximum scale of the pattern. Default: 1.1</param>
		/// <param name="scaleStep">Scale step length (resolution). Default: "auto"</param>
		/// <param name="optimization">Kind of optimization and optionally method used for generating the model. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "ignore_local_polarity"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: 5</param>
		// Token: 0x0600179C RID: 6044 RVA: 0x00097294 File Offset: 0x00095494
		public HShapeModel(HXLDCont contours, int numLevels, double angleStart, double angleExtent, double angleStep, double scaleMin, double scaleMax, double scaleStep, string optimization, string metric, int minContrast)
		{
			IntPtr proc = HalconAPI.PreCall(936);
			HalconAPI.Store(proc, 1, contours);
			HalconAPI.StoreI(proc, 0, numLevels);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, angleStep);
			HalconAPI.StoreD(proc, 4, scaleMin);
			HalconAPI.StoreD(proc, 5, scaleMax);
			HalconAPI.StoreD(proc, 6, scaleStep);
			HalconAPI.StoreS(proc, 7, optimization);
			HalconAPI.StoreS(proc, 8, metric);
			HalconAPI.StoreI(proc, 9, minContrast);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(contours);
		}

		/// <summary>
		///   Prepare a shape model for matching from XLD contours.
		///   Modified instance represents: Handle of the model.
		/// </summary>
		/// <param name="contours">Input contours that will be used to create the model.</param>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">Smallest rotation of the pattern. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="optimization">Kind of optimization and optionally method used for generating the model. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "ignore_local_polarity"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: 5</param>
		// Token: 0x0600179D RID: 6045 RVA: 0x00097340 File Offset: 0x00095540
		public HShapeModel(HXLDCont contours, HTuple numLevels, double angleStart, double angleExtent, HTuple angleStep, HTuple optimization, string metric, int minContrast)
		{
			IntPtr proc = HalconAPI.PreCall(937);
			HalconAPI.Store(proc, 1, contours);
			HalconAPI.Store(proc, 0, numLevels);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.Store(proc, 3, angleStep);
			HalconAPI.Store(proc, 4, optimization);
			HalconAPI.StoreS(proc, 5, metric);
			HalconAPI.StoreI(proc, 6, minContrast);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(numLevels);
			HalconAPI.UnpinTuple(angleStep);
			HalconAPI.UnpinTuple(optimization);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(contours);
		}

		/// <summary>
		///   Prepare a shape model for matching from XLD contours.
		///   Modified instance represents: Handle of the model.
		/// </summary>
		/// <param name="contours">Input contours that will be used to create the model.</param>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">Smallest rotation of the pattern. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="optimization">Kind of optimization and optionally method used for generating the model. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "ignore_local_polarity"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: 5</param>
		// Token: 0x0600179E RID: 6046 RVA: 0x000973E4 File Offset: 0x000955E4
		public HShapeModel(HXLDCont contours, int numLevels, double angleStart, double angleExtent, double angleStep, string optimization, string metric, int minContrast)
		{
			IntPtr proc = HalconAPI.PreCall(937);
			HalconAPI.Store(proc, 1, contours);
			HalconAPI.StoreI(proc, 0, numLevels);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, angleStep);
			HalconAPI.StoreS(proc, 4, optimization);
			HalconAPI.StoreS(proc, 5, metric);
			HalconAPI.StoreI(proc, 6, minContrast);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(contours);
		}

		/// <summary>
		///   Prepare an anisotropically scaled shape model for matching.
		///   Modified instance represents: Handle of the model.
		/// </summary>
		/// <param name="template">Input image whose domain will be used to create the model.</param>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">Smallest rotation of the pattern. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleRMin">Minimum scale of the pattern in the row direction. Default: 0.9</param>
		/// <param name="scaleRMax">Maximum scale of the pattern in the row direction. Default: 1.1</param>
		/// <param name="scaleRStep">Scale step length (resolution) in the row direction. Default: "auto"</param>
		/// <param name="scaleCMin">Minimum scale of the pattern in the column direction. Default: 0.9</param>
		/// <param name="scaleCMax">Maximum scale of the pattern in the column direction. Default: 1.1</param>
		/// <param name="scaleCStep">Scale step length (resolution) in the column direction. Default: "auto"</param>
		/// <param name="optimization">Kind of optimization and optionally method used for generating the model. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "use_polarity"</param>
		/// <param name="contrast">Threshold or hysteresis thresholds for the contrast of the object in the template image and optionally minimum size of the object parts. Default: "auto"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: "auto"</param>
		// Token: 0x0600179F RID: 6047 RVA: 0x00097474 File Offset: 0x00095674
		public HShapeModel(HImage template, HTuple numLevels, double angleStart, double angleExtent, HTuple angleStep, double scaleRMin, double scaleRMax, HTuple scaleRStep, double scaleCMin, double scaleCMax, HTuple scaleCStep, HTuple optimization, string metric, HTuple contrast, HTuple minContrast)
		{
			IntPtr proc = HalconAPI.PreCall(938);
			HalconAPI.Store(proc, 1, template);
			HalconAPI.Store(proc, 0, numLevels);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.Store(proc, 3, angleStep);
			HalconAPI.StoreD(proc, 4, scaleRMin);
			HalconAPI.StoreD(proc, 5, scaleRMax);
			HalconAPI.Store(proc, 6, scaleRStep);
			HalconAPI.StoreD(proc, 7, scaleCMin);
			HalconAPI.StoreD(proc, 8, scaleCMax);
			HalconAPI.Store(proc, 9, scaleCStep);
			HalconAPI.Store(proc, 10, optimization);
			HalconAPI.StoreS(proc, 11, metric);
			HalconAPI.Store(proc, 12, contrast);
			HalconAPI.Store(proc, 13, minContrast);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(numLevels);
			HalconAPI.UnpinTuple(angleStep);
			HalconAPI.UnpinTuple(scaleRStep);
			HalconAPI.UnpinTuple(scaleCStep);
			HalconAPI.UnpinTuple(optimization);
			HalconAPI.UnpinTuple(contrast);
			HalconAPI.UnpinTuple(minContrast);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(template);
		}

		/// <summary>
		///   Prepare an anisotropically scaled shape model for matching.
		///   Modified instance represents: Handle of the model.
		/// </summary>
		/// <param name="template">Input image whose domain will be used to create the model.</param>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">Smallest rotation of the pattern. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleRMin">Minimum scale of the pattern in the row direction. Default: 0.9</param>
		/// <param name="scaleRMax">Maximum scale of the pattern in the row direction. Default: 1.1</param>
		/// <param name="scaleRStep">Scale step length (resolution) in the row direction. Default: "auto"</param>
		/// <param name="scaleCMin">Minimum scale of the pattern in the column direction. Default: 0.9</param>
		/// <param name="scaleCMax">Maximum scale of the pattern in the column direction. Default: 1.1</param>
		/// <param name="scaleCStep">Scale step length (resolution) in the column direction. Default: "auto"</param>
		/// <param name="optimization">Kind of optimization and optionally method used for generating the model. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "use_polarity"</param>
		/// <param name="contrast">Threshold or hysteresis thresholds for the contrast of the object in the template image and optionally minimum size of the object parts. Default: "auto"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: "auto"</param>
		// Token: 0x060017A0 RID: 6048 RVA: 0x00097578 File Offset: 0x00095778
		public HShapeModel(HImage template, int numLevels, double angleStart, double angleExtent, double angleStep, double scaleRMin, double scaleRMax, double scaleRStep, double scaleCMin, double scaleCMax, double scaleCStep, string optimization, string metric, int contrast, int minContrast)
		{
			IntPtr proc = HalconAPI.PreCall(938);
			HalconAPI.Store(proc, 1, template);
			HalconAPI.StoreI(proc, 0, numLevels);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, angleStep);
			HalconAPI.StoreD(proc, 4, scaleRMin);
			HalconAPI.StoreD(proc, 5, scaleRMax);
			HalconAPI.StoreD(proc, 6, scaleRStep);
			HalconAPI.StoreD(proc, 7, scaleCMin);
			HalconAPI.StoreD(proc, 8, scaleCMax);
			HalconAPI.StoreD(proc, 9, scaleCStep);
			HalconAPI.StoreS(proc, 10, optimization);
			HalconAPI.StoreS(proc, 11, metric);
			HalconAPI.StoreI(proc, 12, contrast);
			HalconAPI.StoreI(proc, 13, minContrast);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(template);
		}

		/// <summary>
		///   Prepare an isotropically scaled shape model for matching.
		///   Modified instance represents: Handle of the model.
		/// </summary>
		/// <param name="template">Input image whose domain will be used to create the model.</param>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">Smallest rotation of the pattern. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleMin">Minimum scale of the pattern. Default: 0.9</param>
		/// <param name="scaleMax">Maximum scale of the pattern. Default: 1.1</param>
		/// <param name="scaleStep">Scale step length (resolution). Default: "auto"</param>
		/// <param name="optimization">Kind of optimization and optionally method used for generating the model. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "use_polarity"</param>
		/// <param name="contrast">Threshold or hysteresis thresholds for the contrast of the object in the template image and optionally minimum size of the object parts. Default: "auto"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: "auto"</param>
		// Token: 0x060017A1 RID: 6049 RVA: 0x0009764C File Offset: 0x0009584C
		public HShapeModel(HImage template, HTuple numLevels, double angleStart, double angleExtent, HTuple angleStep, double scaleMin, double scaleMax, HTuple scaleStep, HTuple optimization, string metric, HTuple contrast, HTuple minContrast)
		{
			IntPtr proc = HalconAPI.PreCall(939);
			HalconAPI.Store(proc, 1, template);
			HalconAPI.Store(proc, 0, numLevels);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.Store(proc, 3, angleStep);
			HalconAPI.StoreD(proc, 4, scaleMin);
			HalconAPI.StoreD(proc, 5, scaleMax);
			HalconAPI.Store(proc, 6, scaleStep);
			HalconAPI.Store(proc, 7, optimization);
			HalconAPI.StoreS(proc, 8, metric);
			HalconAPI.Store(proc, 9, contrast);
			HalconAPI.Store(proc, 10, minContrast);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(numLevels);
			HalconAPI.UnpinTuple(angleStep);
			HalconAPI.UnpinTuple(scaleStep);
			HalconAPI.UnpinTuple(optimization);
			HalconAPI.UnpinTuple(contrast);
			HalconAPI.UnpinTuple(minContrast);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(template);
		}

		/// <summary>
		///   Prepare an isotropically scaled shape model for matching.
		///   Modified instance represents: Handle of the model.
		/// </summary>
		/// <param name="template">Input image whose domain will be used to create the model.</param>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">Smallest rotation of the pattern. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleMin">Minimum scale of the pattern. Default: 0.9</param>
		/// <param name="scaleMax">Maximum scale of the pattern. Default: 1.1</param>
		/// <param name="scaleStep">Scale step length (resolution). Default: "auto"</param>
		/// <param name="optimization">Kind of optimization and optionally method used for generating the model. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "use_polarity"</param>
		/// <param name="contrast">Threshold or hysteresis thresholds for the contrast of the object in the template image and optionally minimum size of the object parts. Default: "auto"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: "auto"</param>
		// Token: 0x060017A2 RID: 6050 RVA: 0x0009772C File Offset: 0x0009592C
		public HShapeModel(HImage template, int numLevels, double angleStart, double angleExtent, double angleStep, double scaleMin, double scaleMax, double scaleStep, string optimization, string metric, int contrast, int minContrast)
		{
			IntPtr proc = HalconAPI.PreCall(939);
			HalconAPI.Store(proc, 1, template);
			HalconAPI.StoreI(proc, 0, numLevels);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, angleStep);
			HalconAPI.StoreD(proc, 4, scaleMin);
			HalconAPI.StoreD(proc, 5, scaleMax);
			HalconAPI.StoreD(proc, 6, scaleStep);
			HalconAPI.StoreS(proc, 7, optimization);
			HalconAPI.StoreS(proc, 8, metric);
			HalconAPI.StoreI(proc, 9, contrast);
			HalconAPI.StoreI(proc, 10, minContrast);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(template);
		}

		/// <summary>
		///   Prepare a shape model for matching.
		///   Modified instance represents: Handle of the model.
		/// </summary>
		/// <param name="template">Input image whose domain will be used to create the model.</param>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">Smallest rotation of the pattern. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="optimization">Kind of optimization and optionally method used for generating the model. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "use_polarity"</param>
		/// <param name="contrast">Threshold or hysteresis thresholds for the contrast of the object in the template image and optionally minimum size of the object parts. Default: "auto"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: "auto"</param>
		// Token: 0x060017A3 RID: 6051 RVA: 0x000977E4 File Offset: 0x000959E4
		public HShapeModel(HImage template, HTuple numLevels, double angleStart, double angleExtent, HTuple angleStep, HTuple optimization, string metric, HTuple contrast, HTuple minContrast)
		{
			IntPtr proc = HalconAPI.PreCall(940);
			HalconAPI.Store(proc, 1, template);
			HalconAPI.Store(proc, 0, numLevels);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.Store(proc, 3, angleStep);
			HalconAPI.Store(proc, 4, optimization);
			HalconAPI.StoreS(proc, 5, metric);
			HalconAPI.Store(proc, 6, contrast);
			HalconAPI.Store(proc, 7, minContrast);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(numLevels);
			HalconAPI.UnpinTuple(angleStep);
			HalconAPI.UnpinTuple(optimization);
			HalconAPI.UnpinTuple(contrast);
			HalconAPI.UnpinTuple(minContrast);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(template);
		}

		/// <summary>
		///   Prepare a shape model for matching.
		///   Modified instance represents: Handle of the model.
		/// </summary>
		/// <param name="template">Input image whose domain will be used to create the model.</param>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">Smallest rotation of the pattern. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="optimization">Kind of optimization and optionally method used for generating the model. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "use_polarity"</param>
		/// <param name="contrast">Threshold or hysteresis thresholds for the contrast of the object in the template image and optionally minimum size of the object parts. Default: "auto"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: "auto"</param>
		// Token: 0x060017A4 RID: 6052 RVA: 0x000978A0 File Offset: 0x00095AA0
		public HShapeModel(HImage template, int numLevels, double angleStart, double angleExtent, double angleStep, string optimization, string metric, int contrast, int minContrast)
		{
			IntPtr proc = HalconAPI.PreCall(940);
			HalconAPI.Store(proc, 1, template);
			HalconAPI.StoreI(proc, 0, numLevels);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, angleStep);
			HalconAPI.StoreS(proc, 4, optimization);
			HalconAPI.StoreS(proc, 5, metric);
			HalconAPI.StoreI(proc, 6, contrast);
			HalconAPI.StoreI(proc, 7, minContrast);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(template);
		}

		// Token: 0x060017A5 RID: 6053 RVA: 0x00097938 File Offset: 0x00095B38
		void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
		{
			HSerializedItem hserializedItem = this.SerializeShapeModel();
			byte[] value = hserializedItem;
			hserializedItem.Dispose();
			info.AddValue("data", value, typeof(byte[]));
		}

		// Token: 0x060017A6 RID: 6054 RVA: 0x00097970 File Offset: 0x00095B70
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HShapeModel(SerializationInfo info, StreamingContext context)
		{
			HSerializedItem hserializedItem = new HSerializedItem((byte[])info.GetValue("data", typeof(byte[])));
			this.DeserializeShapeModel(hserializedItem);
			hserializedItem.Dispose();
		}

		/// <summary>Serialize object to binary stream in HALCON format</summary>
		// Token: 0x060017A7 RID: 6055 RVA: 0x000979B0 File Offset: 0x00095BB0
		public new void Serialize(Stream stream)
		{
			HSerializedItem hserializedItem = this.SerializeShapeModel();
			hserializedItem.Serialize(stream);
			hserializedItem.Dispose();
		}

		/// <summary>Deserialize object from binary stream in HALCON format</summary>
		// Token: 0x060017A8 RID: 6056 RVA: 0x000979C4 File Offset: 0x00095BC4
		public new static HShapeModel Deserialize(Stream stream)
		{
			HShapeModel hshapeModel = new HShapeModel();
			HSerializedItem hserializedItem = HSerializedItem.Deserialize(stream);
			hshapeModel.DeserializeShapeModel(hserializedItem);
			hserializedItem.Dispose();
			return hshapeModel;
		}

		// Token: 0x060017A9 RID: 6057 RVA: 0x000979EA File Offset: 0x00095BEA
		object ICloneable.Clone()
		{
			return this.Clone();
		}

		// Token: 0x060017AA RID: 6058 RVA: 0x000979F4 File Offset: 0x00095BF4
		public new HShapeModel Clone()
		{
			HSerializedItem hserializedItem = this.SerializeShapeModel();
			HShapeModel hshapeModel = new HShapeModel();
			hshapeModel.DeserializeShapeModel(hserializedItem);
			hserializedItem.Dispose();
			return hshapeModel;
		}

		/// <summary>
		///   Deserialize a serialized shape model.
		///   Modified instance represents: Handle of the model.
		/// </summary>
		/// <param name="serializedItemHandle">Handle of the serialized item.</param>
		// Token: 0x060017AB RID: 6059 RVA: 0x00097A1C File Offset: 0x00095C1C
		public void DeserializeShapeModel(HSerializedItem serializedItemHandle)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(916);
			HalconAPI.Store(proc, 0, serializedItemHandle);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(serializedItemHandle);
		}

		/// <summary>
		///   Read a shape model from a file.
		///   Modified instance represents: Handle of the model.
		/// </summary>
		/// <param name="fileName">File name.</param>
		// Token: 0x060017AC RID: 6060 RVA: 0x00097A70 File Offset: 0x00095C70
		public void ReadShapeModel(string fileName)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(917);
			HalconAPI.StoreS(proc, 0, fileName);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Serialize a shape model.
		///   Instance represents: Handle of the model.
		/// </summary>
		/// <returns>Handle of the serialized item.</returns>
		// Token: 0x060017AD RID: 6061 RVA: 0x00097ABC File Offset: 0x00095CBC
		public HSerializedItem SerializeShapeModel()
		{
			IntPtr proc = HalconAPI.PreCall(918);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HSerializedItem result;
			num = HSerializedItem.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Write a shape model to a file.
		///   Instance represents: Handle of the model.
		/// </summary>
		/// <param name="fileName">File name.</param>
		// Token: 0x060017AE RID: 6062 RVA: 0x00097B04 File Offset: 0x00095D04
		public void WriteShapeModel(string fileName)
		{
			IntPtr proc = HalconAPI.PreCall(919);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, fileName);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Free the memory of a shape model.
		///   Instance represents: Handle of the model.
		/// </summary>
		// Token: 0x060017AF RID: 6063 RVA: 0x00097B40 File Offset: 0x00095D40
		public void ClearShapeModel()
		{
			IntPtr proc = HalconAPI.PreCall(921);
			base.Store(proc, 0);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Return the contour representation of a shape model.
		///   Instance represents: Handle of the model.
		/// </summary>
		/// <param name="level">Pyramid level for which the contour representation should be returned. Default: 1</param>
		/// <returns>Contour representation of the shape model.</returns>
		// Token: 0x060017B0 RID: 6064 RVA: 0x00097B74 File Offset: 0x00095D74
		public HXLDCont GetShapeModelContours(int level)
		{
			IntPtr proc = HalconAPI.PreCall(922);
			base.Store(proc, 0);
			HalconAPI.StoreI(proc, 1, level);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Return the parameters of a shape model.
		///   Instance represents: Handle of the model.
		/// </summary>
		/// <param name="angleStart">Smallest rotation of the pattern.</param>
		/// <param name="angleExtent">Extent of the rotation angles.</param>
		/// <param name="angleStep">Step length of the angles (resolution).</param>
		/// <param name="scaleMin">Minimum scale of the pattern.</param>
		/// <param name="scaleMax">Maximum scale of the pattern.</param>
		/// <param name="scaleStep">Scale step length (resolution).</param>
		/// <param name="metric">Match metric.</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images.</param>
		/// <returns>Number of pyramid levels.</returns>
		// Token: 0x060017B1 RID: 6065 RVA: 0x00097BC4 File Offset: 0x00095DC4
		public int GetShapeModelParams(out double angleStart, out double angleExtent, out double angleStep, out HTuple scaleMin, out HTuple scaleMax, out HTuple scaleStep, out string metric, out int minContrast)
		{
			IntPtr proc = HalconAPI.PreCall(924);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			HalconAPI.InitOCT(proc, 6);
			HalconAPI.InitOCT(proc, 7);
			HalconAPI.InitOCT(proc, 8);
			int num = HalconAPI.CallProcedure(proc);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out angleStart);
			num = HalconAPI.LoadD(proc, 2, num, out angleExtent);
			num = HalconAPI.LoadD(proc, 3, num, out angleStep);
			num = HTuple.LoadNew(proc, 4, HTupleType.DOUBLE, num, out scaleMin);
			num = HTuple.LoadNew(proc, 5, HTupleType.DOUBLE, num, out scaleMax);
			num = HTuple.LoadNew(proc, 6, HTupleType.DOUBLE, num, out scaleStep);
			num = HalconAPI.LoadS(proc, 7, num, out metric);
			num = HalconAPI.LoadI(proc, 8, num, out minContrast);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Return the parameters of a shape model.
		///   Instance represents: Handle of the model.
		/// </summary>
		/// <param name="angleStart">Smallest rotation of the pattern.</param>
		/// <param name="angleExtent">Extent of the rotation angles.</param>
		/// <param name="angleStep">Step length of the angles (resolution).</param>
		/// <param name="scaleMin">Minimum scale of the pattern.</param>
		/// <param name="scaleMax">Maximum scale of the pattern.</param>
		/// <param name="scaleStep">Scale step length (resolution).</param>
		/// <param name="metric">Match metric.</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images.</param>
		/// <returns>Number of pyramid levels.</returns>
		// Token: 0x060017B2 RID: 6066 RVA: 0x00097CA4 File Offset: 0x00095EA4
		public int GetShapeModelParams(out double angleStart, out double angleExtent, out double angleStep, out double scaleMin, out double scaleMax, out double scaleStep, out string metric, out int minContrast)
		{
			IntPtr proc = HalconAPI.PreCall(924);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			HalconAPI.InitOCT(proc, 6);
			HalconAPI.InitOCT(proc, 7);
			HalconAPI.InitOCT(proc, 8);
			int num = HalconAPI.CallProcedure(proc);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out angleStart);
			num = HalconAPI.LoadD(proc, 2, num, out angleExtent);
			num = HalconAPI.LoadD(proc, 3, num, out angleStep);
			num = HalconAPI.LoadD(proc, 4, num, out scaleMin);
			num = HalconAPI.LoadD(proc, 5, num, out scaleMax);
			num = HalconAPI.LoadD(proc, 6, num, out scaleStep);
			num = HalconAPI.LoadS(proc, 7, num, out metric);
			num = HalconAPI.LoadI(proc, 8, num, out minContrast);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Return the origin (reference point) of a shape model.
		///   Instance represents: Handle of the model.
		/// </summary>
		/// <param name="row">Row coordinate of the origin of the shape model.</param>
		/// <param name="column">Column coordinate of the origin of the shape model.</param>
		// Token: 0x060017B3 RID: 6067 RVA: 0x00097D84 File Offset: 0x00095F84
		public void GetShapeModelOrigin(out double row, out double column)
		{
			IntPtr proc = HalconAPI.PreCall(925);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out row);
			num = HalconAPI.LoadD(proc, 1, num, out column);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Set the origin (reference point) of a shape model.
		///   Instance represents: Handle of the model.
		/// </summary>
		/// <param name="row">Row coordinate of the origin of the shape model.</param>
		/// <param name="column">Column coordinate of the origin of the shape model.</param>
		// Token: 0x060017B4 RID: 6068 RVA: 0x00097DDC File Offset: 0x00095FDC
		public void SetShapeModelOrigin(double row, double column)
		{
			IntPtr proc = HalconAPI.PreCall(926);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, row);
			HalconAPI.StoreD(proc, 2, column);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>Find the best matches of multiple anisotropically scaled shape models.</summary>
		/// <param name="image">Input image in which the models should be found.</param>
		/// <param name="modelIDs">Handle of the models.</param>
		/// <param name="angleStart">Smallest rotation of the models. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="scaleRMin">Minimum scale of the models in the row direction. Default: 0.9</param>
		/// <param name="scaleRMax">Maximum scale of the models in the row direction. Default: 1.1</param>
		/// <param name="scaleCMin">Minimum scale of the models in the column direction. Default: 0.9</param>
		/// <param name="scaleCMax">Maximum scale of the models in the column direction. Default: 1.1</param>
		/// <param name="minScore">Minimum score of the instances of the models to be found. Default: 0.5</param>
		/// <param name="numMatches">Number of instances of the models to be found (or 0 for all matches). Default: 1</param>
		/// <param name="maxOverlap">Maximum overlap of the instances of the models to be found. Default: 0.5</param>
		/// <param name="subPixel">Subpixel accuracy if not equal to 'none'. Default: "least_squares"</param>
		/// <param name="numLevels">Number of pyramid levels used in the matching (and lowest pyramid level to use if $|NumLevels| = 2$). Default: 0</param>
		/// <param name="greediness">"Greediness" of the search heuristic (0: safe but slow; 1: fast but matches may be missed). Default: 0.9</param>
		/// <param name="row">Row coordinate of the found instances of the models.</param>
		/// <param name="column">Column coordinate of the found instances of the models.</param>
		/// <param name="angle">Rotation angle of the found instances of the models.</param>
		/// <param name="scaleR">Scale of the found instances of the models in the row direction.</param>
		/// <param name="scaleC">Scale of the found instances of the models in the column direction.</param>
		/// <param name="score">Score of the found instances of the models.</param>
		/// <param name="model">Index of the found instances of the models.</param>
		// Token: 0x060017B5 RID: 6069 RVA: 0x00097E20 File Offset: 0x00096020
		public static void FindAnisoShapeModels(HImage image, HShapeModel[] modelIDs, HTuple angleStart, HTuple angleExtent, HTuple scaleRMin, HTuple scaleRMax, HTuple scaleCMin, HTuple scaleCMax, HTuple minScore, HTuple numMatches, HTuple maxOverlap, HTuple subPixel, HTuple numLevels, HTuple greediness, out HTuple row, out HTuple column, out HTuple angle, out HTuple scaleR, out HTuple scaleC, out HTuple score, out HTuple model)
		{
			HTuple htuple = HHandleBase.ConcatArray(modelIDs);
			IntPtr proc = HalconAPI.PreCall(927);
			HalconAPI.Store(proc, 1, image);
			HalconAPI.Store(proc, 0, htuple);
			HalconAPI.Store(proc, 1, angleStart);
			HalconAPI.Store(proc, 2, angleExtent);
			HalconAPI.Store(proc, 3, scaleRMin);
			HalconAPI.Store(proc, 4, scaleRMax);
			HalconAPI.Store(proc, 5, scaleCMin);
			HalconAPI.Store(proc, 6, scaleCMax);
			HalconAPI.Store(proc, 7, minScore);
			HalconAPI.Store(proc, 8, numMatches);
			HalconAPI.Store(proc, 9, maxOverlap);
			HalconAPI.Store(proc, 10, subPixel);
			HalconAPI.Store(proc, 11, numLevels);
			HalconAPI.Store(proc, 12, greediness);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			HalconAPI.InitOCT(proc, 6);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.UnpinTuple(angleStart);
			HalconAPI.UnpinTuple(angleExtent);
			HalconAPI.UnpinTuple(scaleRMin);
			HalconAPI.UnpinTuple(scaleRMax);
			HalconAPI.UnpinTuple(scaleCMin);
			HalconAPI.UnpinTuple(scaleCMax);
			HalconAPI.UnpinTuple(minScore);
			HalconAPI.UnpinTuple(numMatches);
			HalconAPI.UnpinTuple(maxOverlap);
			HalconAPI.UnpinTuple(subPixel);
			HalconAPI.UnpinTuple(numLevels);
			HalconAPI.UnpinTuple(greediness);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out column);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out angle);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out scaleR);
			num = HTuple.LoadNew(proc, 4, HTupleType.DOUBLE, num, out scaleC);
			num = HTuple.LoadNew(proc, 5, HTupleType.DOUBLE, num, out score);
			num = HTuple.LoadNew(proc, 6, HTupleType.INTEGER, num, out model);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(image);
			GC.KeepAlive(modelIDs);
		}

		/// <summary>
		///   Find the best matches of multiple anisotropically scaled shape models.
		///   Instance represents: Handle of the models.
		/// </summary>
		/// <param name="image">Input image in which the models should be found.</param>
		/// <param name="angleStart">Smallest rotation of the models. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="scaleRMin">Minimum scale of the models in the row direction. Default: 0.9</param>
		/// <param name="scaleRMax">Maximum scale of the models in the row direction. Default: 1.1</param>
		/// <param name="scaleCMin">Minimum scale of the models in the column direction. Default: 0.9</param>
		/// <param name="scaleCMax">Maximum scale of the models in the column direction. Default: 1.1</param>
		/// <param name="minScore">Minimum score of the instances of the models to be found. Default: 0.5</param>
		/// <param name="numMatches">Number of instances of the models to be found (or 0 for all matches). Default: 1</param>
		/// <param name="maxOverlap">Maximum overlap of the instances of the models to be found. Default: 0.5</param>
		/// <param name="subPixel">Subpixel accuracy if not equal to 'none'. Default: "least_squares"</param>
		/// <param name="numLevels">Number of pyramid levels used in the matching (and lowest pyramid level to use if $|NumLevels| = 2$). Default: 0</param>
		/// <param name="greediness">"Greediness" of the search heuristic (0: safe but slow; 1: fast but matches may be missed). Default: 0.9</param>
		/// <param name="row">Row coordinate of the found instances of the models.</param>
		/// <param name="column">Column coordinate of the found instances of the models.</param>
		/// <param name="angle">Rotation angle of the found instances of the models.</param>
		/// <param name="scaleR">Scale of the found instances of the models in the row direction.</param>
		/// <param name="scaleC">Scale of the found instances of the models in the column direction.</param>
		/// <param name="score">Score of the found instances of the models.</param>
		/// <param name="model">Index of the found instances of the models.</param>
		// Token: 0x060017B6 RID: 6070 RVA: 0x00097FBC File Offset: 0x000961BC
		public void FindAnisoShapeModels(HImage image, double angleStart, double angleExtent, double scaleRMin, double scaleRMax, double scaleCMin, double scaleCMax, double minScore, int numMatches, double maxOverlap, string subPixel, int numLevels, double greediness, out HTuple row, out HTuple column, out HTuple angle, out HTuple scaleR, out HTuple scaleC, out HTuple score, out HTuple model)
		{
			IntPtr proc = HalconAPI.PreCall(927);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, image);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, scaleRMin);
			HalconAPI.StoreD(proc, 4, scaleRMax);
			HalconAPI.StoreD(proc, 5, scaleCMin);
			HalconAPI.StoreD(proc, 6, scaleCMax);
			HalconAPI.StoreD(proc, 7, minScore);
			HalconAPI.StoreI(proc, 8, numMatches);
			HalconAPI.StoreD(proc, 9, maxOverlap);
			HalconAPI.StoreS(proc, 10, subPixel);
			HalconAPI.StoreI(proc, 11, numLevels);
			HalconAPI.StoreD(proc, 12, greediness);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			HalconAPI.InitOCT(proc, 6);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out column);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out angle);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out scaleR);
			num = HTuple.LoadNew(proc, 4, HTupleType.DOUBLE, num, out scaleC);
			num = HTuple.LoadNew(proc, 5, HTupleType.DOUBLE, num, out score);
			num = HTuple.LoadNew(proc, 6, HTupleType.INTEGER, num, out model);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
		}

		/// <summary>Find the best matches of multiple isotropically scaled shape models.</summary>
		/// <param name="image">Input image in which the models should be found.</param>
		/// <param name="modelIDs">Handle of the models.</param>
		/// <param name="angleStart">Smallest rotation of the models. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.78</param>
		/// <param name="scaleMin">Minimum scale of the models. Default: 0.9</param>
		/// <param name="scaleMax">Maximum scale of the models. Default: 1.1</param>
		/// <param name="minScore">Minimum score of the instances of the models to be found. Default: 0.5</param>
		/// <param name="numMatches">Number of instances of the models to be found (or 0 for all matches). Default: 1</param>
		/// <param name="maxOverlap">Maximum overlap of the instances of the models to be found. Default: 0.5</param>
		/// <param name="subPixel">Subpixel accuracy if not equal to 'none'. Default: "least_squares"</param>
		/// <param name="numLevels">Number of pyramid levels used in the matching (and lowest pyramid level to use if $|NumLevels| = 2$). Default: 0</param>
		/// <param name="greediness">"Greediness" of the search heuristic (0: safe but slow; 1: fast but matches may be missed). Default: 0.9</param>
		/// <param name="row">Row coordinate of the found instances of the models.</param>
		/// <param name="column">Column coordinate of the found instances of the models.</param>
		/// <param name="angle">Rotation angle of the found instances of the models.</param>
		/// <param name="scale">Scale of the found instances of the models.</param>
		/// <param name="score">Score of the found instances of the models.</param>
		/// <param name="model">Index of the found instances of the models.</param>
		// Token: 0x060017B7 RID: 6071 RVA: 0x000980F8 File Offset: 0x000962F8
		public static void FindScaledShapeModels(HImage image, HShapeModel[] modelIDs, HTuple angleStart, HTuple angleExtent, HTuple scaleMin, HTuple scaleMax, HTuple minScore, HTuple numMatches, HTuple maxOverlap, HTuple subPixel, HTuple numLevels, HTuple greediness, out HTuple row, out HTuple column, out HTuple angle, out HTuple scale, out HTuple score, out HTuple model)
		{
			HTuple htuple = HHandleBase.ConcatArray(modelIDs);
			IntPtr proc = HalconAPI.PreCall(928);
			HalconAPI.Store(proc, 1, image);
			HalconAPI.Store(proc, 0, htuple);
			HalconAPI.Store(proc, 1, angleStart);
			HalconAPI.Store(proc, 2, angleExtent);
			HalconAPI.Store(proc, 3, scaleMin);
			HalconAPI.Store(proc, 4, scaleMax);
			HalconAPI.Store(proc, 5, minScore);
			HalconAPI.Store(proc, 6, numMatches);
			HalconAPI.Store(proc, 7, maxOverlap);
			HalconAPI.Store(proc, 8, subPixel);
			HalconAPI.Store(proc, 9, numLevels);
			HalconAPI.Store(proc, 10, greediness);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.UnpinTuple(angleStart);
			HalconAPI.UnpinTuple(angleExtent);
			HalconAPI.UnpinTuple(scaleMin);
			HalconAPI.UnpinTuple(scaleMax);
			HalconAPI.UnpinTuple(minScore);
			HalconAPI.UnpinTuple(numMatches);
			HalconAPI.UnpinTuple(maxOverlap);
			HalconAPI.UnpinTuple(subPixel);
			HalconAPI.UnpinTuple(numLevels);
			HalconAPI.UnpinTuple(greediness);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out column);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out angle);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out scale);
			num = HTuple.LoadNew(proc, 4, HTupleType.DOUBLE, num, out score);
			num = HTuple.LoadNew(proc, 5, HTupleType.INTEGER, num, out model);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(image);
			GC.KeepAlive(modelIDs);
		}

		/// <summary>
		///   Find the best matches of multiple isotropically scaled shape models.
		///   Instance represents: Handle of the models.
		/// </summary>
		/// <param name="image">Input image in which the models should be found.</param>
		/// <param name="angleStart">Smallest rotation of the models. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.78</param>
		/// <param name="scaleMin">Minimum scale of the models. Default: 0.9</param>
		/// <param name="scaleMax">Maximum scale of the models. Default: 1.1</param>
		/// <param name="minScore">Minimum score of the instances of the models to be found. Default: 0.5</param>
		/// <param name="numMatches">Number of instances of the models to be found (or 0 for all matches). Default: 1</param>
		/// <param name="maxOverlap">Maximum overlap of the instances of the models to be found. Default: 0.5</param>
		/// <param name="subPixel">Subpixel accuracy if not equal to 'none'. Default: "least_squares"</param>
		/// <param name="numLevels">Number of pyramid levels used in the matching (and lowest pyramid level to use if $|NumLevels| = 2$). Default: 0</param>
		/// <param name="greediness">"Greediness" of the search heuristic (0: safe but slow; 1: fast but matches may be missed). Default: 0.9</param>
		/// <param name="row">Row coordinate of the found instances of the models.</param>
		/// <param name="column">Column coordinate of the found instances of the models.</param>
		/// <param name="angle">Rotation angle of the found instances of the models.</param>
		/// <param name="scale">Scale of the found instances of the models.</param>
		/// <param name="score">Score of the found instances of the models.</param>
		/// <param name="model">Index of the found instances of the models.</param>
		// Token: 0x060017B8 RID: 6072 RVA: 0x00098260 File Offset: 0x00096460
		public void FindScaledShapeModels(HImage image, double angleStart, double angleExtent, double scaleMin, double scaleMax, double minScore, int numMatches, double maxOverlap, string subPixel, int numLevels, double greediness, out HTuple row, out HTuple column, out HTuple angle, out HTuple scale, out HTuple score, out HTuple model)
		{
			IntPtr proc = HalconAPI.PreCall(928);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, image);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, scaleMin);
			HalconAPI.StoreD(proc, 4, scaleMax);
			HalconAPI.StoreD(proc, 5, minScore);
			HalconAPI.StoreI(proc, 6, numMatches);
			HalconAPI.StoreD(proc, 7, maxOverlap);
			HalconAPI.StoreS(proc, 8, subPixel);
			HalconAPI.StoreI(proc, 9, numLevels);
			HalconAPI.StoreD(proc, 10, greediness);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out column);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out angle);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out scale);
			num = HTuple.LoadNew(proc, 4, HTupleType.DOUBLE, num, out score);
			num = HTuple.LoadNew(proc, 5, HTupleType.INTEGER, num, out model);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
		}

		/// <summary>Find the best matches of multiple shape models.</summary>
		/// <param name="image">Input image in which the models should be found.</param>
		/// <param name="modelIDs">Handle of the models.</param>
		/// <param name="angleStart">Smallest rotation of the models. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="minScore">Minimum score of the instances of the models to be found. Default: 0.5</param>
		/// <param name="numMatches">Number of instances of the models to be found (or 0 for all matches). Default: 1</param>
		/// <param name="maxOverlap">Maximum overlap of the instances of the models to be found. Default: 0.5</param>
		/// <param name="subPixel">Subpixel accuracy if not equal to 'none'. Default: "least_squares"</param>
		/// <param name="numLevels">Number of pyramid levels used in the matching (and lowest pyramid level to use if $|NumLevels| = 2$). Default: 0</param>
		/// <param name="greediness">"Greediness" of the search heuristic (0: safe but slow; 1: fast but matches may be missed). Default: 0.9</param>
		/// <param name="row">Row coordinate of the found instances of the models.</param>
		/// <param name="column">Column coordinate of the found instances of the models.</param>
		/// <param name="angle">Rotation angle of the found instances of the models.</param>
		/// <param name="score">Score of the found instances of the models.</param>
		/// <param name="model">Index of the found instances of the models.</param>
		// Token: 0x060017B9 RID: 6073 RVA: 0x00098374 File Offset: 0x00096574
		public static void FindShapeModels(HImage image, HShapeModel[] modelIDs, HTuple angleStart, HTuple angleExtent, HTuple minScore, HTuple numMatches, HTuple maxOverlap, HTuple subPixel, HTuple numLevels, HTuple greediness, out HTuple row, out HTuple column, out HTuple angle, out HTuple score, out HTuple model)
		{
			HTuple htuple = HHandleBase.ConcatArray(modelIDs);
			IntPtr proc = HalconAPI.PreCall(929);
			HalconAPI.Store(proc, 1, image);
			HalconAPI.Store(proc, 0, htuple);
			HalconAPI.Store(proc, 1, angleStart);
			HalconAPI.Store(proc, 2, angleExtent);
			HalconAPI.Store(proc, 3, minScore);
			HalconAPI.Store(proc, 4, numMatches);
			HalconAPI.Store(proc, 5, maxOverlap);
			HalconAPI.Store(proc, 6, subPixel);
			HalconAPI.Store(proc, 7, numLevels);
			HalconAPI.Store(proc, 8, greediness);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.UnpinTuple(angleStart);
			HalconAPI.UnpinTuple(angleExtent);
			HalconAPI.UnpinTuple(minScore);
			HalconAPI.UnpinTuple(numMatches);
			HalconAPI.UnpinTuple(maxOverlap);
			HalconAPI.UnpinTuple(subPixel);
			HalconAPI.UnpinTuple(numLevels);
			HalconAPI.UnpinTuple(greediness);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out column);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out angle);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out score);
			num = HTuple.LoadNew(proc, 4, HTupleType.INTEGER, num, out model);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(image);
			GC.KeepAlive(modelIDs);
		}

		/// <summary>
		///   Find the best matches of multiple shape models.
		///   Instance represents: Handle of the models.
		/// </summary>
		/// <param name="image">Input image in which the models should be found.</param>
		/// <param name="angleStart">Smallest rotation of the models. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="minScore">Minimum score of the instances of the models to be found. Default: 0.5</param>
		/// <param name="numMatches">Number of instances of the models to be found (or 0 for all matches). Default: 1</param>
		/// <param name="maxOverlap">Maximum overlap of the instances of the models to be found. Default: 0.5</param>
		/// <param name="subPixel">Subpixel accuracy if not equal to 'none'. Default: "least_squares"</param>
		/// <param name="numLevels">Number of pyramid levels used in the matching (and lowest pyramid level to use if $|NumLevels| = 2$). Default: 0</param>
		/// <param name="greediness">"Greediness" of the search heuristic (0: safe but slow; 1: fast but matches may be missed). Default: 0.9</param>
		/// <param name="row">Row coordinate of the found instances of the models.</param>
		/// <param name="column">Column coordinate of the found instances of the models.</param>
		/// <param name="angle">Rotation angle of the found instances of the models.</param>
		/// <param name="score">Score of the found instances of the models.</param>
		/// <param name="model">Index of the found instances of the models.</param>
		// Token: 0x060017BA RID: 6074 RVA: 0x000984A4 File Offset: 0x000966A4
		public void FindShapeModels(HImage image, double angleStart, double angleExtent, double minScore, int numMatches, double maxOverlap, string subPixel, int numLevels, double greediness, out HTuple row, out HTuple column, out HTuple angle, out HTuple score, out HTuple model)
		{
			IntPtr proc = HalconAPI.PreCall(929);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, image);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, minScore);
			HalconAPI.StoreI(proc, 4, numMatches);
			HalconAPI.StoreD(proc, 5, maxOverlap);
			HalconAPI.StoreS(proc, 6, subPixel);
			HalconAPI.StoreI(proc, 7, numLevels);
			HalconAPI.StoreD(proc, 8, greediness);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out column);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out angle);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out score);
			num = HTuple.LoadNew(proc, 4, HTupleType.INTEGER, num, out model);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
		}

		/// <summary>
		///   Find the best matches of an anisotropically scaled shape model in an image.
		///   Instance represents: Handle of the model.
		/// </summary>
		/// <param name="image">Input image in which the model should be found.</param>
		/// <param name="angleStart">Smallest rotation of the model. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="scaleRMin">Minimum scale of the model in the row direction. Default: 0.9</param>
		/// <param name="scaleRMax">Maximum scale of the model in the row direction. Default: 1.1</param>
		/// <param name="scaleCMin">Minimum scale of the model in the column direction. Default: 0.9</param>
		/// <param name="scaleCMax">Maximum scale of the model in the column direction. Default: 1.1</param>
		/// <param name="minScore">Minimum score of the instances of the model to be found. Default: 0.5</param>
		/// <param name="numMatches">Number of instances of the model to be found (or 0 for all matches). Default: 1</param>
		/// <param name="maxOverlap">Maximum overlap of the instances of the model to be found. Default: 0.5</param>
		/// <param name="subPixel">Subpixel accuracy if not equal to 'none'. Default: "least_squares"</param>
		/// <param name="numLevels">Number of pyramid levels used in the matching (and lowest pyramid level to use if $|NumLevels| = 2$). Default: 0</param>
		/// <param name="greediness">"Greediness" of the search heuristic (0: safe but slow; 1: fast but matches may be missed). Default: 0.9</param>
		/// <param name="row">Row coordinate of the found instances of the model.</param>
		/// <param name="column">Column coordinate of the found instances of the model.</param>
		/// <param name="angle">Rotation angle of the found instances of the model.</param>
		/// <param name="scaleR">Scale of the found instances of the model in the row direction.</param>
		/// <param name="scaleC">Scale of the found instances of the model in the column direction.</param>
		/// <param name="score">Score of the found instances of the model.</param>
		// Token: 0x060017BB RID: 6075 RVA: 0x00098590 File Offset: 0x00096790
		public void FindAnisoShapeModel(HImage image, double angleStart, double angleExtent, double scaleRMin, double scaleRMax, double scaleCMin, double scaleCMax, HTuple minScore, int numMatches, double maxOverlap, HTuple subPixel, HTuple numLevels, double greediness, out HTuple row, out HTuple column, out HTuple angle, out HTuple scaleR, out HTuple scaleC, out HTuple score)
		{
			IntPtr proc = HalconAPI.PreCall(930);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, image);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, scaleRMin);
			HalconAPI.StoreD(proc, 4, scaleRMax);
			HalconAPI.StoreD(proc, 5, scaleCMin);
			HalconAPI.StoreD(proc, 6, scaleCMax);
			HalconAPI.Store(proc, 7, minScore);
			HalconAPI.StoreI(proc, 8, numMatches);
			HalconAPI.StoreD(proc, 9, maxOverlap);
			HalconAPI.Store(proc, 10, subPixel);
			HalconAPI.Store(proc, 11, numLevels);
			HalconAPI.StoreD(proc, 12, greediness);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(minScore);
			HalconAPI.UnpinTuple(subPixel);
			HalconAPI.UnpinTuple(numLevels);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out column);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out angle);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out scaleR);
			num = HTuple.LoadNew(proc, 4, HTupleType.DOUBLE, num, out scaleC);
			num = HTuple.LoadNew(proc, 5, HTupleType.DOUBLE, num, out score);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
		}

		/// <summary>
		///   Find the best matches of an anisotropically scaled shape model in an image.
		///   Instance represents: Handle of the model.
		/// </summary>
		/// <param name="image">Input image in which the model should be found.</param>
		/// <param name="angleStart">Smallest rotation of the model. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="scaleRMin">Minimum scale of the model in the row direction. Default: 0.9</param>
		/// <param name="scaleRMax">Maximum scale of the model in the row direction. Default: 1.1</param>
		/// <param name="scaleCMin">Minimum scale of the model in the column direction. Default: 0.9</param>
		/// <param name="scaleCMax">Maximum scale of the model in the column direction. Default: 1.1</param>
		/// <param name="minScore">Minimum score of the instances of the model to be found. Default: 0.5</param>
		/// <param name="numMatches">Number of instances of the model to be found (or 0 for all matches). Default: 1</param>
		/// <param name="maxOverlap">Maximum overlap of the instances of the model to be found. Default: 0.5</param>
		/// <param name="subPixel">Subpixel accuracy if not equal to 'none'. Default: "least_squares"</param>
		/// <param name="numLevels">Number of pyramid levels used in the matching (and lowest pyramid level to use if $|NumLevels| = 2$). Default: 0</param>
		/// <param name="greediness">"Greediness" of the search heuristic (0: safe but slow; 1: fast but matches may be missed). Default: 0.9</param>
		/// <param name="row">Row coordinate of the found instances of the model.</param>
		/// <param name="column">Column coordinate of the found instances of the model.</param>
		/// <param name="angle">Rotation angle of the found instances of the model.</param>
		/// <param name="scaleR">Scale of the found instances of the model in the row direction.</param>
		/// <param name="scaleC">Scale of the found instances of the model in the column direction.</param>
		/// <param name="score">Score of the found instances of the model.</param>
		// Token: 0x060017BC RID: 6076 RVA: 0x000986D0 File Offset: 0x000968D0
		public void FindAnisoShapeModel(HImage image, double angleStart, double angleExtent, double scaleRMin, double scaleRMax, double scaleCMin, double scaleCMax, double minScore, int numMatches, double maxOverlap, string subPixel, int numLevels, double greediness, out HTuple row, out HTuple column, out HTuple angle, out HTuple scaleR, out HTuple scaleC, out HTuple score)
		{
			IntPtr proc = HalconAPI.PreCall(930);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, image);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, scaleRMin);
			HalconAPI.StoreD(proc, 4, scaleRMax);
			HalconAPI.StoreD(proc, 5, scaleCMin);
			HalconAPI.StoreD(proc, 6, scaleCMax);
			HalconAPI.StoreD(proc, 7, minScore);
			HalconAPI.StoreI(proc, 8, numMatches);
			HalconAPI.StoreD(proc, 9, maxOverlap);
			HalconAPI.StoreS(proc, 10, subPixel);
			HalconAPI.StoreI(proc, 11, numLevels);
			HalconAPI.StoreD(proc, 12, greediness);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out column);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out angle);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out scaleR);
			num = HTuple.LoadNew(proc, 4, HTupleType.DOUBLE, num, out scaleC);
			num = HTuple.LoadNew(proc, 5, HTupleType.DOUBLE, num, out score);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
		}

		/// <summary>
		///   Find the best matches of an isotropically scaled shape model in an image.
		///   Instance represents: Handle of the model.
		/// </summary>
		/// <param name="image">Input image in which the model should be found.</param>
		/// <param name="angleStart">Smallest rotation of the model. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.78</param>
		/// <param name="scaleMin">Minimum scale of the model. Default: 0.9</param>
		/// <param name="scaleMax">Maximum scale of the model. Default: 1.1</param>
		/// <param name="minScore">Minimum score of the instances of the model to be found. Default: 0.5</param>
		/// <param name="numMatches">Number of instances of the model to be found (or 0 for all matches). Default: 1</param>
		/// <param name="maxOverlap">Maximum overlap of the instances of the model to be found. Default: 0.5</param>
		/// <param name="subPixel">Subpixel accuracy if not equal to 'none'. Default: "least_squares"</param>
		/// <param name="numLevels">Number of pyramid levels used in the matching (and lowest pyramid level to use if $|NumLevels| = 2$). Default: 0</param>
		/// <param name="greediness">"Greediness" of the search heuristic (0: safe but slow; 1: fast but matches may be missed). Default: 0.9</param>
		/// <param name="row">Row coordinate of the found instances of the model.</param>
		/// <param name="column">Column coordinate of the found instances of the model.</param>
		/// <param name="angle">Rotation angle of the found instances of the model.</param>
		/// <param name="scale">Scale of the found instances of the model.</param>
		/// <param name="score">Score of the found instances of the model.</param>
		// Token: 0x060017BD RID: 6077 RVA: 0x000987F8 File Offset: 0x000969F8
		public void FindScaledShapeModel(HImage image, double angleStart, double angleExtent, double scaleMin, double scaleMax, HTuple minScore, int numMatches, double maxOverlap, HTuple subPixel, HTuple numLevels, double greediness, out HTuple row, out HTuple column, out HTuple angle, out HTuple scale, out HTuple score)
		{
			IntPtr proc = HalconAPI.PreCall(931);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, image);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, scaleMin);
			HalconAPI.StoreD(proc, 4, scaleMax);
			HalconAPI.Store(proc, 5, minScore);
			HalconAPI.StoreI(proc, 6, numMatches);
			HalconAPI.StoreD(proc, 7, maxOverlap);
			HalconAPI.Store(proc, 8, subPixel);
			HalconAPI.Store(proc, 9, numLevels);
			HalconAPI.StoreD(proc, 10, greediness);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(minScore);
			HalconAPI.UnpinTuple(subPixel);
			HalconAPI.UnpinTuple(numLevels);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out column);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out angle);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out scale);
			num = HTuple.LoadNew(proc, 4, HTupleType.DOUBLE, num, out score);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
		}

		/// <summary>
		///   Find the best matches of an isotropically scaled shape model in an image.
		///   Instance represents: Handle of the model.
		/// </summary>
		/// <param name="image">Input image in which the model should be found.</param>
		/// <param name="angleStart">Smallest rotation of the model. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.78</param>
		/// <param name="scaleMin">Minimum scale of the model. Default: 0.9</param>
		/// <param name="scaleMax">Maximum scale of the model. Default: 1.1</param>
		/// <param name="minScore">Minimum score of the instances of the model to be found. Default: 0.5</param>
		/// <param name="numMatches">Number of instances of the model to be found (or 0 for all matches). Default: 1</param>
		/// <param name="maxOverlap">Maximum overlap of the instances of the model to be found. Default: 0.5</param>
		/// <param name="subPixel">Subpixel accuracy if not equal to 'none'. Default: "least_squares"</param>
		/// <param name="numLevels">Number of pyramid levels used in the matching (and lowest pyramid level to use if $|NumLevels| = 2$). Default: 0</param>
		/// <param name="greediness">"Greediness" of the search heuristic (0: safe but slow; 1: fast but matches may be missed). Default: 0.9</param>
		/// <param name="row">Row coordinate of the found instances of the model.</param>
		/// <param name="column">Column coordinate of the found instances of the model.</param>
		/// <param name="angle">Rotation angle of the found instances of the model.</param>
		/// <param name="scale">Scale of the found instances of the model.</param>
		/// <param name="score">Score of the found instances of the model.</param>
		// Token: 0x060017BE RID: 6078 RVA: 0x00098910 File Offset: 0x00096B10
		public void FindScaledShapeModel(HImage image, double angleStart, double angleExtent, double scaleMin, double scaleMax, double minScore, int numMatches, double maxOverlap, string subPixel, int numLevels, double greediness, out HTuple row, out HTuple column, out HTuple angle, out HTuple scale, out HTuple score)
		{
			IntPtr proc = HalconAPI.PreCall(931);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, image);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, scaleMin);
			HalconAPI.StoreD(proc, 4, scaleMax);
			HalconAPI.StoreD(proc, 5, minScore);
			HalconAPI.StoreI(proc, 6, numMatches);
			HalconAPI.StoreD(proc, 7, maxOverlap);
			HalconAPI.StoreS(proc, 8, subPixel);
			HalconAPI.StoreI(proc, 9, numLevels);
			HalconAPI.StoreD(proc, 10, greediness);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out column);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out angle);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out scale);
			num = HTuple.LoadNew(proc, 4, HTupleType.DOUBLE, num, out score);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
		}

		/// <summary>
		///   Find the best matches of a shape model in an image.
		///   Instance represents: Handle of the model.
		/// </summary>
		/// <param name="image">Input image in which the model should be found.</param>
		/// <param name="angleStart">Smallest rotation of the model. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="minScore">Minimum score of the instances of the model to be found. Default: 0.5</param>
		/// <param name="numMatches">Number of instances of the model to be found (or 0 for all matches). Default: 1</param>
		/// <param name="maxOverlap">Maximum overlap of the instances of the model to be found. Default: 0.5</param>
		/// <param name="subPixel">Subpixel accuracy if not equal to 'none'. Default: "least_squares"</param>
		/// <param name="numLevels">Number of pyramid levels used in the matching (and lowest pyramid level to use if $|NumLevels| = 2$). Default: 0</param>
		/// <param name="greediness">"Greediness" of the search heuristic (0: safe but slow; 1: fast but matches may be missed). Default: 0.9</param>
		/// <param name="row">Row coordinate of the found instances of the model.</param>
		/// <param name="column">Column coordinate of the found instances of the model.</param>
		/// <param name="angle">Rotation angle of the found instances of the model.</param>
		/// <param name="score">Score of the found instances of the model.</param>
		// Token: 0x060017BF RID: 6079 RVA: 0x00098A10 File Offset: 0x00096C10
		public void FindShapeModel(HImage image, double angleStart, double angleExtent, HTuple minScore, int numMatches, double maxOverlap, HTuple subPixel, HTuple numLevels, double greediness, out HTuple row, out HTuple column, out HTuple angle, out HTuple score)
		{
			IntPtr proc = HalconAPI.PreCall(932);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, image);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.Store(proc, 3, minScore);
			HalconAPI.StoreI(proc, 4, numMatches);
			HalconAPI.StoreD(proc, 5, maxOverlap);
			HalconAPI.Store(proc, 6, subPixel);
			HalconAPI.Store(proc, 7, numLevels);
			HalconAPI.StoreD(proc, 8, greediness);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(minScore);
			HalconAPI.UnpinTuple(subPixel);
			HalconAPI.UnpinTuple(numLevels);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out column);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out angle);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out score);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
		}

		/// <summary>
		///   Find the best matches of a shape model in an image.
		///   Instance represents: Handle of the model.
		/// </summary>
		/// <param name="image">Input image in which the model should be found.</param>
		/// <param name="angleStart">Smallest rotation of the model. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="minScore">Minimum score of the instances of the model to be found. Default: 0.5</param>
		/// <param name="numMatches">Number of instances of the model to be found (or 0 for all matches). Default: 1</param>
		/// <param name="maxOverlap">Maximum overlap of the instances of the model to be found. Default: 0.5</param>
		/// <param name="subPixel">Subpixel accuracy if not equal to 'none'. Default: "least_squares"</param>
		/// <param name="numLevels">Number of pyramid levels used in the matching (and lowest pyramid level to use if $|NumLevels| = 2$). Default: 0</param>
		/// <param name="greediness">"Greediness" of the search heuristic (0: safe but slow; 1: fast but matches may be missed). Default: 0.9</param>
		/// <param name="row">Row coordinate of the found instances of the model.</param>
		/// <param name="column">Column coordinate of the found instances of the model.</param>
		/// <param name="angle">Rotation angle of the found instances of the model.</param>
		/// <param name="score">Score of the found instances of the model.</param>
		// Token: 0x060017C0 RID: 6080 RVA: 0x00098B00 File Offset: 0x00096D00
		public void FindShapeModel(HImage image, double angleStart, double angleExtent, double minScore, int numMatches, double maxOverlap, string subPixel, int numLevels, double greediness, out HTuple row, out HTuple column, out HTuple angle, out HTuple score)
		{
			IntPtr proc = HalconAPI.PreCall(932);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, image);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, minScore);
			HalconAPI.StoreI(proc, 4, numMatches);
			HalconAPI.StoreD(proc, 5, maxOverlap);
			HalconAPI.StoreS(proc, 6, subPixel);
			HalconAPI.StoreI(proc, 7, numLevels);
			HalconAPI.StoreD(proc, 8, greediness);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out column);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out angle);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out score);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
		}

		/// <summary>
		///   Set the metric of a shape model that was created from XLD contours.
		///   Instance represents: Handle of the model.
		/// </summary>
		/// <param name="image">Input image used for the determination of the polarity.</param>
		/// <param name="homMat2D">Transformation matrix.</param>
		/// <param name="metric">Match metric. Default: "use_polarity"</param>
		// Token: 0x060017C1 RID: 6081 RVA: 0x00098BD8 File Offset: 0x00096DD8
		public void SetShapeModelMetric(HImage image, HHomMat2D homMat2D, string metric)
		{
			IntPtr proc = HalconAPI.PreCall(933);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, image);
			HalconAPI.Store(proc, 1, homMat2D);
			HalconAPI.StoreS(proc, 2, metric);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(homMat2D);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
		}

		/// <summary>
		///   Set selected parameters of the shape model.
		///   Instance represents: Handle of the model.
		/// </summary>
		/// <param name="genParamName">Parameter names.</param>
		/// <param name="genParamValue">Parameter values.</param>
		// Token: 0x060017C2 RID: 6082 RVA: 0x00098C3C File Offset: 0x00096E3C
		public void SetShapeModelParam(HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(934);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, genParamName);
			HalconAPI.Store(proc, 2, genParamValue);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Prepare an anisotropically scaled shape model for matching from XLD contours.
		///   Modified instance represents: Handle of the model.
		/// </summary>
		/// <param name="contours">Input contours that will be used to create the model.</param>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">Smallest rotation of the pattern. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleRMin">Minimum scale of the pattern in the row direction. Default: 0.9</param>
		/// <param name="scaleRMax">Maximum scale of the pattern in the row direction. Default: 1.1</param>
		/// <param name="scaleRStep">Scale step length (resolution) in the row direction. Default: "auto"</param>
		/// <param name="scaleCMin">Minimum scale of the pattern in the column direction. Default: 0.9</param>
		/// <param name="scaleCMax">Maximum scale of the pattern in the column direction. Default: 1.1</param>
		/// <param name="scaleCStep">Scale step length (resolution) in the column direction. Default: "auto"</param>
		/// <param name="optimization">Kind of optimization and optionally method used for generating the model. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "ignore_local_polarity"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: 5</param>
		// Token: 0x060017C3 RID: 6083 RVA: 0x00098C8C File Offset: 0x00096E8C
		public void CreateAnisoShapeModelXld(HXLDCont contours, HTuple numLevels, double angleStart, double angleExtent, HTuple angleStep, double scaleRMin, double scaleRMax, HTuple scaleRStep, double scaleCMin, double scaleCMax, HTuple scaleCStep, HTuple optimization, string metric, int minContrast)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(935);
			HalconAPI.Store(proc, 1, contours);
			HalconAPI.Store(proc, 0, numLevels);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.Store(proc, 3, angleStep);
			HalconAPI.StoreD(proc, 4, scaleRMin);
			HalconAPI.StoreD(proc, 5, scaleRMax);
			HalconAPI.Store(proc, 6, scaleRStep);
			HalconAPI.StoreD(proc, 7, scaleCMin);
			HalconAPI.StoreD(proc, 8, scaleCMax);
			HalconAPI.Store(proc, 9, scaleCStep);
			HalconAPI.Store(proc, 10, optimization);
			HalconAPI.StoreS(proc, 11, metric);
			HalconAPI.StoreI(proc, 12, minContrast);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(numLevels);
			HalconAPI.UnpinTuple(angleStep);
			HalconAPI.UnpinTuple(scaleRStep);
			HalconAPI.UnpinTuple(scaleCStep);
			HalconAPI.UnpinTuple(optimization);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(contours);
		}

		/// <summary>
		///   Prepare an anisotropically scaled shape model for matching from XLD contours.
		///   Modified instance represents: Handle of the model.
		/// </summary>
		/// <param name="contours">Input contours that will be used to create the model.</param>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">Smallest rotation of the pattern. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleRMin">Minimum scale of the pattern in the row direction. Default: 0.9</param>
		/// <param name="scaleRMax">Maximum scale of the pattern in the row direction. Default: 1.1</param>
		/// <param name="scaleRStep">Scale step length (resolution) in the row direction. Default: "auto"</param>
		/// <param name="scaleCMin">Minimum scale of the pattern in the column direction. Default: 0.9</param>
		/// <param name="scaleCMax">Maximum scale of the pattern in the column direction. Default: 1.1</param>
		/// <param name="scaleCStep">Scale step length (resolution) in the column direction. Default: "auto"</param>
		/// <param name="optimization">Kind of optimization and optionally method used for generating the model. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "ignore_local_polarity"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: 5</param>
		// Token: 0x060017C4 RID: 6084 RVA: 0x00098D78 File Offset: 0x00096F78
		public void CreateAnisoShapeModelXld(HXLDCont contours, int numLevels, double angleStart, double angleExtent, double angleStep, double scaleRMin, double scaleRMax, double scaleRStep, double scaleCMin, double scaleCMax, double scaleCStep, string optimization, string metric, int minContrast)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(935);
			HalconAPI.Store(proc, 1, contours);
			HalconAPI.StoreI(proc, 0, numLevels);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, angleStep);
			HalconAPI.StoreD(proc, 4, scaleRMin);
			HalconAPI.StoreD(proc, 5, scaleRMax);
			HalconAPI.StoreD(proc, 6, scaleRStep);
			HalconAPI.StoreD(proc, 7, scaleCMin);
			HalconAPI.StoreD(proc, 8, scaleCMax);
			HalconAPI.StoreD(proc, 9, scaleCStep);
			HalconAPI.StoreS(proc, 10, optimization);
			HalconAPI.StoreS(proc, 11, metric);
			HalconAPI.StoreI(proc, 12, minContrast);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(contours);
		}

		/// <summary>
		///   Prepare an isotropically scaled shape model for matching from XLD contours.
		///   Modified instance represents: Handle of the model.
		/// </summary>
		/// <param name="contours">Input contours that will be used to create the model.</param>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">Smallest rotation of the pattern. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleMin">Minimum scale of the pattern. Default: 0.9</param>
		/// <param name="scaleMax">Maximum scale of the pattern. Default: 1.1</param>
		/// <param name="scaleStep">Scale step length (resolution). Default: "auto"</param>
		/// <param name="optimization">Kind of optimization and optionally method used for generating the model. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "ignore_local_polarity"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: 5</param>
		// Token: 0x060017C5 RID: 6085 RVA: 0x00098E44 File Offset: 0x00097044
		public void CreateScaledShapeModelXld(HXLDCont contours, HTuple numLevels, double angleStart, double angleExtent, HTuple angleStep, double scaleMin, double scaleMax, HTuple scaleStep, HTuple optimization, string metric, int minContrast)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(936);
			HalconAPI.Store(proc, 1, contours);
			HalconAPI.Store(proc, 0, numLevels);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.Store(proc, 3, angleStep);
			HalconAPI.StoreD(proc, 4, scaleMin);
			HalconAPI.StoreD(proc, 5, scaleMax);
			HalconAPI.Store(proc, 6, scaleStep);
			HalconAPI.Store(proc, 7, optimization);
			HalconAPI.StoreS(proc, 8, metric);
			HalconAPI.StoreI(proc, 9, minContrast);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(numLevels);
			HalconAPI.UnpinTuple(angleStep);
			HalconAPI.UnpinTuple(scaleStep);
			HalconAPI.UnpinTuple(optimization);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(contours);
		}

		/// <summary>
		///   Prepare an isotropically scaled shape model for matching from XLD contours.
		///   Modified instance represents: Handle of the model.
		/// </summary>
		/// <param name="contours">Input contours that will be used to create the model.</param>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">Smallest rotation of the pattern. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleMin">Minimum scale of the pattern. Default: 0.9</param>
		/// <param name="scaleMax">Maximum scale of the pattern. Default: 1.1</param>
		/// <param name="scaleStep">Scale step length (resolution). Default: "auto"</param>
		/// <param name="optimization">Kind of optimization and optionally method used for generating the model. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "ignore_local_polarity"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: 5</param>
		// Token: 0x060017C6 RID: 6086 RVA: 0x00098F0C File Offset: 0x0009710C
		public void CreateScaledShapeModelXld(HXLDCont contours, int numLevels, double angleStart, double angleExtent, double angleStep, double scaleMin, double scaleMax, double scaleStep, string optimization, string metric, int minContrast)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(936);
			HalconAPI.Store(proc, 1, contours);
			HalconAPI.StoreI(proc, 0, numLevels);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, angleStep);
			HalconAPI.StoreD(proc, 4, scaleMin);
			HalconAPI.StoreD(proc, 5, scaleMax);
			HalconAPI.StoreD(proc, 6, scaleStep);
			HalconAPI.StoreS(proc, 7, optimization);
			HalconAPI.StoreS(proc, 8, metric);
			HalconAPI.StoreI(proc, 9, minContrast);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(contours);
		}

		/// <summary>
		///   Prepare a shape model for matching from XLD contours.
		///   Modified instance represents: Handle of the model.
		/// </summary>
		/// <param name="contours">Input contours that will be used to create the model.</param>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">Smallest rotation of the pattern. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="optimization">Kind of optimization and optionally method used for generating the model. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "ignore_local_polarity"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: 5</param>
		// Token: 0x060017C7 RID: 6087 RVA: 0x00098FB8 File Offset: 0x000971B8
		public void CreateShapeModelXld(HXLDCont contours, HTuple numLevels, double angleStart, double angleExtent, HTuple angleStep, HTuple optimization, string metric, int minContrast)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(937);
			HalconAPI.Store(proc, 1, contours);
			HalconAPI.Store(proc, 0, numLevels);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.Store(proc, 3, angleStep);
			HalconAPI.Store(proc, 4, optimization);
			HalconAPI.StoreS(proc, 5, metric);
			HalconAPI.StoreI(proc, 6, minContrast);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(numLevels);
			HalconAPI.UnpinTuple(angleStep);
			HalconAPI.UnpinTuple(optimization);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(contours);
		}

		/// <summary>
		///   Prepare a shape model for matching from XLD contours.
		///   Modified instance represents: Handle of the model.
		/// </summary>
		/// <param name="contours">Input contours that will be used to create the model.</param>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">Smallest rotation of the pattern. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="optimization">Kind of optimization and optionally method used for generating the model. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "ignore_local_polarity"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: 5</param>
		// Token: 0x060017C8 RID: 6088 RVA: 0x0009905C File Offset: 0x0009725C
		public void CreateShapeModelXld(HXLDCont contours, int numLevels, double angleStart, double angleExtent, double angleStep, string optimization, string metric, int minContrast)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(937);
			HalconAPI.Store(proc, 1, contours);
			HalconAPI.StoreI(proc, 0, numLevels);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, angleStep);
			HalconAPI.StoreS(proc, 4, optimization);
			HalconAPI.StoreS(proc, 5, metric);
			HalconAPI.StoreI(proc, 6, minContrast);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(contours);
		}

		/// <summary>
		///   Prepare an anisotropically scaled shape model for matching.
		///   Modified instance represents: Handle of the model.
		/// </summary>
		/// <param name="template">Input image whose domain will be used to create the model.</param>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">Smallest rotation of the pattern. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleRMin">Minimum scale of the pattern in the row direction. Default: 0.9</param>
		/// <param name="scaleRMax">Maximum scale of the pattern in the row direction. Default: 1.1</param>
		/// <param name="scaleRStep">Scale step length (resolution) in the row direction. Default: "auto"</param>
		/// <param name="scaleCMin">Minimum scale of the pattern in the column direction. Default: 0.9</param>
		/// <param name="scaleCMax">Maximum scale of the pattern in the column direction. Default: 1.1</param>
		/// <param name="scaleCStep">Scale step length (resolution) in the column direction. Default: "auto"</param>
		/// <param name="optimization">Kind of optimization and optionally method used for generating the model. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "use_polarity"</param>
		/// <param name="contrast">Threshold or hysteresis thresholds for the contrast of the object in the template image and optionally minimum size of the object parts. Default: "auto"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: "auto"</param>
		// Token: 0x060017C9 RID: 6089 RVA: 0x000990EC File Offset: 0x000972EC
		public void CreateAnisoShapeModel(HImage template, HTuple numLevels, double angleStart, double angleExtent, HTuple angleStep, double scaleRMin, double scaleRMax, HTuple scaleRStep, double scaleCMin, double scaleCMax, HTuple scaleCStep, HTuple optimization, string metric, HTuple contrast, HTuple minContrast)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(938);
			HalconAPI.Store(proc, 1, template);
			HalconAPI.Store(proc, 0, numLevels);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.Store(proc, 3, angleStep);
			HalconAPI.StoreD(proc, 4, scaleRMin);
			HalconAPI.StoreD(proc, 5, scaleRMax);
			HalconAPI.Store(proc, 6, scaleRStep);
			HalconAPI.StoreD(proc, 7, scaleCMin);
			HalconAPI.StoreD(proc, 8, scaleCMax);
			HalconAPI.Store(proc, 9, scaleCStep);
			HalconAPI.Store(proc, 10, optimization);
			HalconAPI.StoreS(proc, 11, metric);
			HalconAPI.Store(proc, 12, contrast);
			HalconAPI.Store(proc, 13, minContrast);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(numLevels);
			HalconAPI.UnpinTuple(angleStep);
			HalconAPI.UnpinTuple(scaleRStep);
			HalconAPI.UnpinTuple(scaleCStep);
			HalconAPI.UnpinTuple(optimization);
			HalconAPI.UnpinTuple(contrast);
			HalconAPI.UnpinTuple(minContrast);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(template);
		}

		/// <summary>
		///   Prepare an anisotropically scaled shape model for matching.
		///   Modified instance represents: Handle of the model.
		/// </summary>
		/// <param name="template">Input image whose domain will be used to create the model.</param>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">Smallest rotation of the pattern. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleRMin">Minimum scale of the pattern in the row direction. Default: 0.9</param>
		/// <param name="scaleRMax">Maximum scale of the pattern in the row direction. Default: 1.1</param>
		/// <param name="scaleRStep">Scale step length (resolution) in the row direction. Default: "auto"</param>
		/// <param name="scaleCMin">Minimum scale of the pattern in the column direction. Default: 0.9</param>
		/// <param name="scaleCMax">Maximum scale of the pattern in the column direction. Default: 1.1</param>
		/// <param name="scaleCStep">Scale step length (resolution) in the column direction. Default: "auto"</param>
		/// <param name="optimization">Kind of optimization and optionally method used for generating the model. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "use_polarity"</param>
		/// <param name="contrast">Threshold or hysteresis thresholds for the contrast of the object in the template image and optionally minimum size of the object parts. Default: "auto"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: "auto"</param>
		// Token: 0x060017CA RID: 6090 RVA: 0x000991F0 File Offset: 0x000973F0
		public void CreateAnisoShapeModel(HImage template, int numLevels, double angleStart, double angleExtent, double angleStep, double scaleRMin, double scaleRMax, double scaleRStep, double scaleCMin, double scaleCMax, double scaleCStep, string optimization, string metric, int contrast, int minContrast)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(938);
			HalconAPI.Store(proc, 1, template);
			HalconAPI.StoreI(proc, 0, numLevels);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, angleStep);
			HalconAPI.StoreD(proc, 4, scaleRMin);
			HalconAPI.StoreD(proc, 5, scaleRMax);
			HalconAPI.StoreD(proc, 6, scaleRStep);
			HalconAPI.StoreD(proc, 7, scaleCMin);
			HalconAPI.StoreD(proc, 8, scaleCMax);
			HalconAPI.StoreD(proc, 9, scaleCStep);
			HalconAPI.StoreS(proc, 10, optimization);
			HalconAPI.StoreS(proc, 11, metric);
			HalconAPI.StoreI(proc, 12, contrast);
			HalconAPI.StoreI(proc, 13, minContrast);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(template);
		}

		/// <summary>
		///   Prepare an isotropically scaled shape model for matching.
		///   Modified instance represents: Handle of the model.
		/// </summary>
		/// <param name="template">Input image whose domain will be used to create the model.</param>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">Smallest rotation of the pattern. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleMin">Minimum scale of the pattern. Default: 0.9</param>
		/// <param name="scaleMax">Maximum scale of the pattern. Default: 1.1</param>
		/// <param name="scaleStep">Scale step length (resolution). Default: "auto"</param>
		/// <param name="optimization">Kind of optimization and optionally method used for generating the model. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "use_polarity"</param>
		/// <param name="contrast">Threshold or hysteresis thresholds for the contrast of the object in the template image and optionally minimum size of the object parts. Default: "auto"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: "auto"</param>
		// Token: 0x060017CB RID: 6091 RVA: 0x000992C4 File Offset: 0x000974C4
		public void CreateScaledShapeModel(HImage template, HTuple numLevels, double angleStart, double angleExtent, HTuple angleStep, double scaleMin, double scaleMax, HTuple scaleStep, HTuple optimization, string metric, HTuple contrast, HTuple minContrast)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(939);
			HalconAPI.Store(proc, 1, template);
			HalconAPI.Store(proc, 0, numLevels);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.Store(proc, 3, angleStep);
			HalconAPI.StoreD(proc, 4, scaleMin);
			HalconAPI.StoreD(proc, 5, scaleMax);
			HalconAPI.Store(proc, 6, scaleStep);
			HalconAPI.Store(proc, 7, optimization);
			HalconAPI.StoreS(proc, 8, metric);
			HalconAPI.Store(proc, 9, contrast);
			HalconAPI.Store(proc, 10, minContrast);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(numLevels);
			HalconAPI.UnpinTuple(angleStep);
			HalconAPI.UnpinTuple(scaleStep);
			HalconAPI.UnpinTuple(optimization);
			HalconAPI.UnpinTuple(contrast);
			HalconAPI.UnpinTuple(minContrast);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(template);
		}

		/// <summary>
		///   Prepare an isotropically scaled shape model for matching.
		///   Modified instance represents: Handle of the model.
		/// </summary>
		/// <param name="template">Input image whose domain will be used to create the model.</param>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">Smallest rotation of the pattern. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleMin">Minimum scale of the pattern. Default: 0.9</param>
		/// <param name="scaleMax">Maximum scale of the pattern. Default: 1.1</param>
		/// <param name="scaleStep">Scale step length (resolution). Default: "auto"</param>
		/// <param name="optimization">Kind of optimization and optionally method used for generating the model. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "use_polarity"</param>
		/// <param name="contrast">Threshold or hysteresis thresholds for the contrast of the object in the template image and optionally minimum size of the object parts. Default: "auto"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: "auto"</param>
		// Token: 0x060017CC RID: 6092 RVA: 0x000993A4 File Offset: 0x000975A4
		public void CreateScaledShapeModel(HImage template, int numLevels, double angleStart, double angleExtent, double angleStep, double scaleMin, double scaleMax, double scaleStep, string optimization, string metric, int contrast, int minContrast)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(939);
			HalconAPI.Store(proc, 1, template);
			HalconAPI.StoreI(proc, 0, numLevels);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, angleStep);
			HalconAPI.StoreD(proc, 4, scaleMin);
			HalconAPI.StoreD(proc, 5, scaleMax);
			HalconAPI.StoreD(proc, 6, scaleStep);
			HalconAPI.StoreS(proc, 7, optimization);
			HalconAPI.StoreS(proc, 8, metric);
			HalconAPI.StoreI(proc, 9, contrast);
			HalconAPI.StoreI(proc, 10, minContrast);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(template);
		}

		/// <summary>
		///   Prepare a shape model for matching.
		///   Modified instance represents: Handle of the model.
		/// </summary>
		/// <param name="template">Input image whose domain will be used to create the model.</param>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">Smallest rotation of the pattern. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="optimization">Kind of optimization and optionally method used for generating the model. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "use_polarity"</param>
		/// <param name="contrast">Threshold or hysteresis thresholds for the contrast of the object in the template image and optionally minimum size of the object parts. Default: "auto"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: "auto"</param>
		// Token: 0x060017CD RID: 6093 RVA: 0x0009945C File Offset: 0x0009765C
		public void CreateShapeModel(HImage template, HTuple numLevels, double angleStart, double angleExtent, HTuple angleStep, HTuple optimization, string metric, HTuple contrast, HTuple minContrast)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(940);
			HalconAPI.Store(proc, 1, template);
			HalconAPI.Store(proc, 0, numLevels);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.Store(proc, 3, angleStep);
			HalconAPI.Store(proc, 4, optimization);
			HalconAPI.StoreS(proc, 5, metric);
			HalconAPI.Store(proc, 6, contrast);
			HalconAPI.Store(proc, 7, minContrast);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(numLevels);
			HalconAPI.UnpinTuple(angleStep);
			HalconAPI.UnpinTuple(optimization);
			HalconAPI.UnpinTuple(contrast);
			HalconAPI.UnpinTuple(minContrast);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(template);
		}

		/// <summary>
		///   Prepare a shape model for matching.
		///   Modified instance represents: Handle of the model.
		/// </summary>
		/// <param name="template">Input image whose domain will be used to create the model.</param>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">Smallest rotation of the pattern. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="optimization">Kind of optimization and optionally method used for generating the model. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "use_polarity"</param>
		/// <param name="contrast">Threshold or hysteresis thresholds for the contrast of the object in the template image and optionally minimum size of the object parts. Default: "auto"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: "auto"</param>
		// Token: 0x060017CE RID: 6094 RVA: 0x00099518 File Offset: 0x00097718
		public void CreateShapeModel(HImage template, int numLevels, double angleStart, double angleExtent, double angleStep, string optimization, string metric, int contrast, int minContrast)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(940);
			HalconAPI.Store(proc, 1, template);
			HalconAPI.StoreI(proc, 0, numLevels);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, angleStep);
			HalconAPI.StoreS(proc, 4, optimization);
			HalconAPI.StoreS(proc, 5, metric);
			HalconAPI.StoreI(proc, 6, contrast);
			HalconAPI.StoreI(proc, 7, minContrast);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(template);
		}

		/// <summary>
		///   Get the clutter parameters of a shape model.
		///   Instance represents: Handle of the model.
		/// </summary>
		/// <param name="genParamName">Parameter names. Default: "use_clutter"</param>
		/// <param name="genParamValue">Parameter values.</param>
		/// <param name="homMat2D">Transformation matrix.</param>
		/// <param name="clutterContrast">Minimum contrast of clutter in the search images.</param>
		/// <returns>Region where no clutter should occur.</returns>
		// Token: 0x060017CF RID: 6095 RVA: 0x000995B0 File Offset: 0x000977B0
		public HRegion GetShapeModelClutter(HTuple genParamName, out HTuple genParamValue, out HHomMat2D homMat2D, out int clutterContrast)
		{
			IntPtr proc = HalconAPI.PreCall(2178);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, genParamName);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			num = HTuple.LoadNew(proc, 0, num, out genParamValue);
			num = HHomMat2D.LoadNew(proc, 1, num, out homMat2D);
			num = HalconAPI.LoadI(proc, 2, num, out clutterContrast);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Get the clutter parameters of a shape model.
		///   Instance represents: Handle of the model.
		/// </summary>
		/// <param name="genParamName">Parameter names. Default: "use_clutter"</param>
		/// <param name="genParamValue">Parameter values.</param>
		/// <param name="homMat2D">Transformation matrix.</param>
		/// <param name="clutterContrast">Minimum contrast of clutter in the search images.</param>
		/// <returns>Region where no clutter should occur.</returns>
		// Token: 0x060017D0 RID: 6096 RVA: 0x00099640 File Offset: 0x00097840
		public HRegion GetShapeModelClutter(string genParamName, out string genParamValue, out HHomMat2D homMat2D, out int clutterContrast)
		{
			IntPtr proc = HalconAPI.PreCall(2178);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, genParamName);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			num = HalconAPI.LoadS(proc, 0, num, out genParamValue);
			num = HHomMat2D.LoadNew(proc, 1, num, out homMat2D);
			num = HalconAPI.LoadI(proc, 2, num, out clutterContrast);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///    Set the clutter parameters of a shape model.
		///   Instance represents: Handle of the model.
		/// </summary>
		/// <param name="clutterRegion">Region where no clutter should occur.</param>
		/// <param name="homMat2D">Transformation matrix.</param>
		/// <param name="clutterContrast">Minimum contrast of clutter in the search images. Default: 128</param>
		/// <param name="genParamName">Parameter names.</param>
		/// <param name="genParamValue">Parameter values.</param>
		// Token: 0x060017D1 RID: 6097 RVA: 0x000996C8 File Offset: 0x000978C8
		public void SetShapeModelClutter(HRegion clutterRegion, HHomMat2D homMat2D, int clutterContrast, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(2180);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, clutterRegion);
			HalconAPI.Store(proc, 1, homMat2D);
			HalconAPI.StoreI(proc, 2, clutterContrast);
			HalconAPI.Store(proc, 3, genParamName);
			HalconAPI.Store(proc, 4, genParamValue);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(homMat2D);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(clutterRegion);
		}

		/// <summary>
		///    Set the clutter parameters of a shape model.
		///   Instance represents: Handle of the model.
		/// </summary>
		/// <param name="clutterRegion">Region where no clutter should occur.</param>
		/// <param name="homMat2D">Transformation matrix.</param>
		/// <param name="clutterContrast">Minimum contrast of clutter in the search images. Default: 128</param>
		/// <param name="genParamName">Parameter names.</param>
		/// <param name="genParamValue">Parameter values.</param>
		// Token: 0x060017D2 RID: 6098 RVA: 0x0009974C File Offset: 0x0009794C
		public void SetShapeModelClutter(HRegion clutterRegion, HHomMat2D homMat2D, int clutterContrast, string genParamName, double genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(2180);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, clutterRegion);
			HalconAPI.Store(proc, 1, homMat2D);
			HalconAPI.StoreI(proc, 2, clutterContrast);
			HalconAPI.StoreS(proc, 3, genParamName);
			HalconAPI.StoreD(proc, 4, genParamValue);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(homMat2D);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(clutterRegion);
		}
	}
}
